home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / POGOSRC.ARC / CALL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  6.5 KB  |  357 lines
  1.  
  2. #include <stdio.h>
  3. #include "pogo.h"
  4.  
  5. int fret_type = INT;
  6.  
  7. call_func(sym, rvalue, rtype)
  8. Symbol *sym;
  9. int rvalue;    /* returns a value? */
  10. int rtype;
  11. {
  12. struct func_frame *fuf;
  13. void *code;
  14. unsigned char ptypes[MAX_PARAMS];
  15. int pcount;
  16.  
  17. fuf = sym->symval.p;
  18. if (fuf->ret_type != rtype)
  19.     {
  20.     say_fatal("function returns wrong type");
  21.     return;
  22.     }
  23. need_token();
  24. if (cttype != TOK_LPAREN)
  25.     {
  26.     expecting_got("(", ctoke);
  27.     return;
  28.     }
  29. pcount = 0;
  30. need_token();
  31. if (cttype != TOK_RPAREN)
  32.     {
  33.     pushback_token();
  34.     for (;;)
  35.         {
  36.         if ((ptypes[pcount] = get_expression()) == BAD)
  37.             return;
  38.         pcount++;
  39.         if (got_stop)
  40.             return;
  41.         need_token();
  42.         if (cttype == TOK_RPAREN)
  43.             break;
  44.         else if (cttype != ',')
  45.             {
  46.             expecting_com_rpar();
  47.             return;
  48.             }
  49.         if (pcount >= MAX_PARAMS)
  50.             {
  51.             too_many_params();
  52.             }
  53.         }
  54.     }
  55. if (sym->type == FFFUNC)
  56.     {
  57.     fuf->pcount = pcount;
  58.     sym->type = FFUNC;
  59.     copy_bytes(ptypes, fuf->ptypes, pcount);
  60.     }
  61. if (!check_params(sym->name, fuf, ptypes, pcount))
  62.     return;
  63. if (sym->type == FUNC)
  64.     {
  65.     if (rvalue)
  66.         {
  67.         if (fuf->ret_type == STRING)
  68.             code_big(OP_CALLS, fuf);
  69.         else
  70.             code_big(OP_CALL, fuf);
  71.         }
  72.     else
  73.         code_big(OP_PCALL, fuf);
  74.     }
  75. else if (sym->type == PREDEF)
  76.     {
  77.     if (rvalue)
  78.         {
  79.         if (fuf->ret_type == STRING)
  80.             code_big(OP_PREDEFL, fuf->code);
  81.         else
  82.             code_big(OP_PREDEF, fuf->code);
  83.         }
  84.     else
  85.         code_big(OP_PPREDEF, fuf->code);
  86.     }
  87. else
  88.     {
  89.     if (!add_fff(sym) )
  90.         return;
  91.     if (rvalue)
  92.         if (fuf->ret_type == STRING)
  93.             code_big(OP_CALLS, fuf);
  94.         else
  95.             code_big(OP_CALL, fuf);
  96.     else
  97.         code_big(OP_PCALL, fuf);
  98.     }
  99. if (pcount != 0)
  100.     {
  101.     if (!rvalue) /* if it doesnt retunr a value just clear params */
  102.         {
  103.         code_num(OP_MOVES, (NUMBER)-pcount);
  104.         }
  105.     else
  106.         {
  107.         code_num(OP_RETRIEVE, (NUMBER)-pcount);
  108. #ifdef LATER
  109.         if (pcount != 1)
  110.             code_num(OP_MOVES, (NUMBER)1-pcount);
  111. #endif LATER
  112.         }
  113.     }
  114. }
  115.  
  116.  
  117. /* this puppy checks if an undefined name is the 1st part of a function
  118.    call.  If not return 0.  If so go call func and return 1 */
  119. precall_func(rvalue,rtype)
  120. int rvalue;    /* returns a value */
  121. int rtype;
  122. {
  123. char fname[MAX_SYM_LEN];
  124. Symbol *ns;
  125. struct func_frame *fuf;
  126.  
  127. strcpy(fname, ctoke);    /* save name */
  128. if (!next_token())
  129.     return(0);
  130. pushback_token();
  131. if (cttype == '(')
  132.     {
  133.     if ((fuf = beg_zero(sizeof(*fuf))) == NULL)
  134.         return(0);
  135.     /* Undefined functions get hung on global frame */
  136.     if ((ns = new_symbol(fname, FFFUNC, GLOBAL, global_frame)) != NULL)
  137.         {
  138.         ns->symval.p = (void *)fuf;
  139.         fuf->ret_type = rtype;
  140.         call_func(ns, rvalue, rtype);
  141.         if (global_err)
  142.             {
  143.             missing_function(fname);
  144.             }
  145.         }
  146.     if (next_token())
  147.         {
  148.         if (cttype == TOK_LBRACE)
  149.             {
  150.             missing_function(fname);
  151.             }
  152.         pushback_token();
  153.         }
  154.     return(1);
  155.     }
  156. else
  157.     {
  158.     return(0);
  159.     }
  160. }
  161.  
  162. /* declare a function */
  163. get_function()
  164. {
  165. Symbol *sym;
  166. Symbol *parameters, *np;
  167. struct func_frame *fuf;
  168. int pcount, poff;
  169. unsigned char ptypes[MAX_PARAMS];
  170. int ptype;
  171.  
  172. if (in_func)
  173.     {
  174.     say_fatal("No functions defined in a function");
  175.     return;
  176.     }
  177. if (in_loop)
  178.     {
  179.     say_fatal("No functions defined in a loop, while, or for");
  180.     return;
  181.     }
  182. if (in_creature)
  183.     {
  184.     say_fatal("No functions defined in a creature");
  185.     return;
  186.     }
  187. if (!need_token())
  188.     return;
  189. if (cttype == TOK_INT)
  190.     fret_type = INT;
  191. else if (cttype == TOK_STRING)
  192.     fret_type = STRING;
  193. else
  194.     {
  195.     fret_type = INT;
  196.     pushback_token();
  197.     }
  198. if (!need_token())
  199.     return;
  200. if (cttype == TOK_VAR && csym->type == FFUNC)
  201.     sym = csym;
  202. else
  203.     {
  204.     if (cttype != TOK_UNDEF)
  205.         {
  206.         redefined(ctoke);
  207.         return;
  208.         }
  209.     if ((sym = new_symbol(ctoke, FFUNC, GLOBAL, rframe)) == NULL)
  210.         return;
  211.     }
  212. eat_token(LPAREN_STR);
  213. if (!need_token())
  214.     return;
  215. parameters = NULL;
  216. pcount = 0;
  217. if (cttype != TOK_RPAREN)
  218.     {
  219.     pushback_token();
  220.     for (;;)
  221.         {
  222.         if (!need_token())
  223.             return;
  224.         ptype = INT;
  225.         if (cttype == TOK_INT)
  226.             {
  227.             }
  228.         else if (cttype == TOK_STRING)
  229.             {
  230.             ptype = STRING;
  231.             }
  232.         else
  233.             pushback_token();
  234.         if (!need_token())
  235.             return;
  236.         if (cttype !=TOK_UNDEF)
  237.             {
  238.             if (cttype == TOK_VAR)
  239.                 redefined(ctoke);
  240.             else
  241.                 expecting_got("name", ctoke);
  242.             return;
  243.             }
  244.         if ((np = named_symbol(ctoke, ptype, LOCAL)) == NULL)
  245.             return;
  246.         np->next = parameters;
  247.         np->assigned = 1;
  248.         parameters = np;
  249.         ptypes[pcount] = ptype;
  250.         pcount++;
  251.         if (!need_token())
  252.             return;
  253.         if (cttype == TOK_RPAREN)
  254.             {
  255.             break;
  256.             }
  257.         if (cttype != ',')
  258.             {
  259.             expecting_com_rpar();
  260.             return;
  261.             }
  262.         if (pcount >= MAX_PARAMS)
  263.             {
  264.             too_many_params(sym->name);
  265.             return;
  266.             }
  267.         }
  268.     }
  269. poff = -2;
  270. np = parameters;
  271. while (np != NULL)
  272.     {
  273.     np->doff = poff;
  274.     np = np->next;
  275.     poff -= 1;
  276.     }
  277. fuf = (struct func_frame *)sym->symval.p;
  278. if (fuf == NULL)
  279.     {
  280.     if ((fuf = (struct func_frame *)beg_zero(sizeof(*fuf))) == NULL)
  281.         {
  282.         return;
  283.         }
  284.     sym->symval.p = (void *)fuf;
  285.     fuf->pcount = pcount;
  286.     copy_bytes(ptypes, fuf->ptypes, pcount);
  287.     }
  288. else
  289.     {
  290.     if (!check_params(sym->name, fuf, ptypes, pcount))
  291.         {
  292.         return;
  293.         }
  294.     }
  295. if (!eat_token(LBRACE_STR))
  296.     return;
  297. new_frame();
  298. rframe->pcount = pcount;
  299. rframe->symbols = parameters;
  300. rframe->ret_type = fret_type;
  301. in_func = 1;
  302. pogo_func(pcount);
  303. if (got_stop)
  304.     return;
  305. in_func = 0;
  306. if (!eat_token(RBRACE_STR))
  307.     {
  308.     return;
  309.     }
  310. save_function(sym, fuf);
  311. sym->type = FUNC;
  312. old_frame();
  313. fret_type = INT;
  314. return;
  315. }
  316.  
  317.  
  318. /* do what it takes to save code and symbols in function we just parsed */
  319. /* do what forward reference fixup we can to the function (goto's) and */
  320. /* proceed to transform static sized pogo_frame pointer to keep track of */
  321. /* it all into a dynamically sized func_frame pointer */
  322. save_function(fs, fuf)
  323. Symbol *fs;
  324. struct func_frame *fuf;
  325. {
  326. struct pogo_op *code;
  327. int csize;
  328. int cpsize;
  329.  
  330. /* want to hang function symbol on parent's frame */
  331. cpsize = rframe->op_count + 1;
  332. csize = cpsize * sizeof(*code);
  333. if ((code = (struct pogo_op *)beg_mem(csize)) == NULL)
  334.     {
  335.     return(0);
  336.     }
  337. /* put in operation to skip past local variables on stack */
  338. code->type = OP_MOVES;
  339. code->data.p = NULL;    /* make disassembly look neater */
  340. code->data.i = rframe->dcount+fuf->pcount;
  341. /* copy rest of function as is */
  342. copy_bytes(rframe->code_buf, code+1, csize-1*sizeof(*code));
  343. fuf->code = code;
  344. fuf->code_size = cpsize;
  345. fuf->symbols = rframe->symbols;
  346. fuf->ffixes = rframe->ffixes;
  347. fuf->crw_fixes = rframe->crw_fixes;
  348. fuf->dcount = rframe->dcount;
  349. fuf->ret_type = rframe->ret_type;
  350. fuf->name = fs->name;
  351. fuf->next = ff_list;
  352. ff_list = fuf;
  353. fs->symval.p = fuf;
  354. return(1);
  355. }
  356.  
  357.